import request from './request'
import { OrderAPIRequestParam } from '@/typings/api/order'
import axios, { AxiosPromise, Canceler } from 'axios'

const cancelToken = axios.CancelToken
let cancel: Canceler = () => {
  // 取消请求
}

/**
 * 创建或修改工单保存
 * @param data - 请求参数
 * @param data.accountability - 责任归属(责任方)：1=工厂问题，2=客人问题
 * @param data.agingBegin - 时效开始时间
 * @param data.buyPlatformOrderNo - 购买平台订单号
 * @param data.content - 故障描述
 * @param data.createTime - 报单时间
 * @param data.delImageIds - 删除的工单附件ID集合
 * @param data.delOrderGoodsIds - 删除的工单商品对象ID集合
 * @param data.departmentId - 部门Id
 * @param data.documentPreparationDate - 制单时间
 * @param data.empId - 人员表ID，即客服ID，0表示按规则分配客服
 * @param data.faultDescribe - 故障描述(反馈内容)
 * @param data.faultReason - 故障原因
 * @param data.faultRelationVos - 故障现象
 * @param data.faultTypeRelationVos - 工单故障分类对象
 * @param data.id - 工单ID，新增不必传，修改必传
 * @param data.imageVos - 工单附件
 * @param data.moduleId - 工单模块ID
 * @param data.networkEmpId - 网点工程师ID
 * @param data.networkId - 网点表ID
 * @param data.oneTypeId - 工单模块分类ID1
 * @param data.oneWayId - 工单模块方式ID1
 * @param data.orderGoodsTypes - 工单商品类型对象
 * @param data.orderReservationDate - 预约日期-仅工单报单时填入
 * @param data.orderReservationEndTime - 预约结束时间-仅工单报单时填入
 * @param data.orderReservationStartTime - 预约开始时间-仅工单报单时填入
 * @param data.orderUser - 工单客户对象
 * @param data.otherOrderNo - 第三方关联单
 * @param data.overinsured - 质保状态，是否保外：false-保内，true-保外
 * @param data.remark - 客服备注/工单备注说明
 * @param data.saleChannel - 销售渠道：1=天猫，2=抖音，3=线下，4=商用
 * @param data.serviceMode - 服务方式：1=上门，2=远程，3=返厂
 * @param data.serviceType - 服务类型：1=维修、2=翻新、3=检测、4=安装、5=保养、6=报废评估、7=其他
 * @param data.solution - 解决方案/措施
 * @param data.source - 工单来源：1-系统报单/线下工单，2-客户小程序报单，3-工程师小程序报单，4、客户APP报单，5-Excel导入工单，6-400工单，7-公众号报单，8-神州联保第三方报单，9-万师傅第三方报单，10-客户H5端报单，11-快可立第三方，12-工程师H5端报单
 * @param data.thirdExtraContentJson - 第三方要求的额外工单字段
 * @param data.threeTypeId - 工单模块分类ID3
 * @param data.threeWayId - 工单模块方式ID3
 * @param data.twoTypeId - 工单模块分类ID2
 * @param data.twoWayId - 工单模块方式ID2
 * @param data.videos - 视频
 * @param data.workFieldVal - 工单自定义字段值对象
 * @param data.workGoodsType - 工单产品类型：0=无/无归属，1=商用，2-家用
 * @param data.workImages - 工单附件的不同类型集合
 * @param data.workLevelId - 工单级别ID
 * @param data.workSourceId - 工单来源ID
 */
export function addSave(data: OrderAPIRequest.FormSaveParam): AxiosPromise<APIResponse> {
  return request({
    url: '/work/order/save',
    method: 'post',
    data,
  })
}

/**
 * 获取工单模块下拉选项
 * @param data - 请求参数
 * @param data.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param data.departmentId - 部门ID
 * @param data.id - 搜索ID
 * @param data.limit - 每页显示数量
 * @param data.name - 搜索关键词
 * @param data.page - 当面页码
 */
export function workModulePageSelect(data: {
  ascriptionType: '' | 1 | 2
  departmentId: string
  id: string
  limit: number
  name: string
  page: number
}): AxiosPromise<OrderAPIResponse.ModuleOptions> {
  return request({
    url: '/order/select/workModulePageSelect',
    method: 'post',
    data,
  })
}

/**
 * 工单级别下拉列表查询
 * @param data - 请求参数
 * @param data.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param data.departmentId - 部门ID
 * @param data.id - 搜索ID
 * @param data.limit - 每页显示数量
 * @param data.name - 搜索关键词
 * @param data.page - 当面页码
 */
export function workLevelPageSelect(data: {
  ascriptionType: '' | 1 | 2
  departmentId: string
  id: string
  limit: number
  name: string
  page: number
}) {
  return request({
    url: '/order/select/workLevelPageSelect',
    method: 'post',
    data,
  })
}

/**
 * 工单客服组下拉列表查询
 * @param data - 请求参数
 * @param data.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param data.departmentId - 部门ID
 * @param data.id - 搜索ID
 * @param data.limit - 每页显示数量
 * @param data.name - 搜索关键词
 * @param data.page - 当面页码
 */
export function workTeamPageSelect(data: {
  ascriptionType: '' | 1 | 2
  departmentId: string
  id: string
  limit: number
  name: string
  page: number
}) {
  return request({
    url: '/order/select/workTeamPageSelect',
    method: 'post',
    data,
  })
}

/**
 * 分页获取公司下拉数据，带出所有联系人及对应的账号
 * @param data - 请求参数
 * @param data.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param data.departmentId - 部门ID
 * @param data.id - 搜索ID
 * @param data.limit - 每页显示数量
 * @param data.name - 搜索关键词
 * @param data.page - 当面页码
 */
export function getUserSelect(data: {
  ascriptionType: '' | 1 | 2
  departmentId: string
  id: string
  limit: number
  name: string
  page: number
}): AxiosPromise<CustomerAPIResponse.CustomerOptionList> {
  return request({
    url: '/select/user/pageUserSelect',
    method: 'post',
    data,
  })
}

/**
 * 用户联系人下拉数据列表
 * @param data - 请求参数
 * @param data.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param data.departmentId - 部门ID
 * @param data.id - 搜索ID
 * @param data.limit - 每页显示数量
 * @param data.name - 搜索关键词
 * @param data.page - 当面页码
 * @param userId - 用户ID
 */
export function userSelect(
  data: {
    ascriptionType: '' | 1 | 2
    departmentId: string
    id: string
    limit: number
    name: string
    page: number
  },
  userId: string,
) {
  return request({
    url: '/select/user/' + userId,
    method: 'post',
    data,
  })
}

/**
 * 获取工单报单产品
 * @param data - 请求参数
 * @param data.brandId - 品牌ID
 * @param data.limit - 每页显示数量
 * @param data.model - 搜索关键词：商品型号/商品名称/商品规格
 * @param data.name - 搜索关键词：商品型号/商品名称/商品规格
 * @param data.page - 当面页码
 * @param data.saleModels - 销售型号
 * @param data.specs - 搜索关键词：商品型号/商品名称/商品规格
 * @param data.typeId - 一级商品分类ID
 * @param data.typeThreeId - 三级商品分类ID
 * @param data.typeTwoId - 二级商品分类ID
 * @param data.visible - 可见性--->只生效与小程序
 */
export function getOrderProduct(data: {
  brandId: string
  limit: number
  model: string
  name: string
  page: number
  saleModels: string
  specs: string
  typeId: string
  typeThreeId: string
  typeTwoId: string
  visible: number
}): AxiosPromise<OrderAPIResponse.GoodList> {
  return request({
    url: '/goods/product/getOrderProduct',
    method: 'post',
    data,
  })
}

/**
 * 工单模块处理方式下拉列表查询
 * @param data - 请求参数
 * @param data.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param data.departmentId - 部门ID
 * @param data.id - 搜索ID
 * @param data.limit - 每页显示数量
 * @param data.name - 搜索关键词
 * @param data.page - 当面页码
 * @param moduleId - 模块id
 */
export const workModuleWayPageSelect = (
  data: {
    ascriptionType: '' | 1 | 2
    departmentId: string
    id: string
    limit: number
    name: string
    page: number
  },
  moduleId: string,
): AxiosPromise<OrderAPIResponse.ModuleHandleMethodOptions> => {
  return request({
    url: '/order/select/workModuleWayPageSelect/' + moduleId,
    method: 'post',
    data,
  })
}

/**
 * 工单模块分类下拉列表查询
 * @param data - 请求参数
 * @param data.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param data.departmentId - 部门ID
 * @param data.id - 搜索ID
 * @param data.limit - 每页显示数量
 * @param data.name - 搜索关键词
 * @param data.page - 当面页码
 * @param moduleId - 模块id
 */
export const workModuleTypePageSelect = (
  data: {
    ascriptionType: '' | 1 | 2
    departmentId: string
    id: string
    limit: number
    name: string
    page: number
  },
  moduleId: string,
): AxiosPromise<OrderAPIResponse.ModuleTypeOptions> => {
  return request({
    url: '/order/select/workModuleTypePageSelect/' + moduleId,
    method: 'post',
    data,
  })
}

/**
 * 获取工单列表
 * @param data - 请求参数
 * @param data.agingFiltrate - 完工时效筛选: 超过 24、48、72、96小时
 * @param data.buyPlatformOrderNo - 平台订单号
 * @param data.childStatus - 子状态：待服务商处理：1-服务商未接单，2-服务商未派单，3-工程师未接单；处理中：1-未拨打电话，2-未预约，3-未签到，4-费用待审核，5-配件待审核
 * @param data.dateFieldType - 时间字段类型：1-报单日期，2-完工日期
 * @param data.dateType - 报单时间类型：1-时间区间，2-今天，3-本周，4-本月，5-过去三个月
 * @param data.departmentId - 部门ID
 * @param data.empIds - 客服ID
 * @param data.empType - 客服类型：1-已分配客服，0-未分配客服，传空值则查询所有
 * @param data.engineer - 工程师关键词搜索：工程师名称/工程师手机号
 * @param data.fieldId - 工单字段ID
 * @param data.fieldSearch - 工单字段搜索关键词
 * @param data.goodsCode - 商品编号
 * @param data.goodsSearch - 商品搜索：品牌/产品名称/产品型号
 * @param data.limit - 每页显示数量
 * @param data.maxServiceTime - 最大服务时长值
 * @param data.minServiceTime - 最小服务时长值
 * @param data.moduleIds - 工单模块ID
 * @param data.networkIds - 服务区域ID
 * @param data.networkType - 网点类型：1-已派单，0-未派单，传空值则查询所有
 * @param data.orderEndTime - 报单结束时间
 * @param data.orderNo - 工单单号
 * @param data.orderNodeTimeoutType - 工单节点时效类型：0-未超时工单，1-已超时工单
 * @param data.orderStartTime - 报单开始时间
 * @param data.orderStatus - 工单状态：1-待派单，2-待服务商确认，3-处理中，4-已完成，5-已取消
 * @param data.orderUserSearch - 工单客户搜索关键词：客户名称/客户手机号/客户地址
 * @param data.otherOrderNo - 第三方关联单号
 * @param data.page - 当面页码
 * @param data.sendForRepairPhone - 反馈人员手机号
 * @param data.sendForRepairUsername - 反馈人员名称
 * @param data.serviceTimeType - 服务时长类型：1-小时，2-天
 * @param data.snCode - NS码/一物一码
 * @param data.sources - 工单来源
 * @param data.sql - AOP使用
 * @param data.status - 工单状态：1-待派单，2-待服务商处理，3-处理中，4-已完成，5-已作废，1001-结单审核 1002-已结算 1003-未结算
 * @param data.userArea - 客户报单地址-县/区
 * @param data.userCity - 客户报单地址-市
 * @param data.userProvince - 客户报单地址-省
 * @param data.workLevelIds - 等级ID
 * @param data.workSourceIds - 工单来源IdList
 */
export function getOrderList(
  data: OrderAPIRequest.GetList,
): AxiosPromise<APIResponseList<OrderListItem>> {
  return request({
    url: '/work/order/getList',
    method: 'post',
    data,
  })
}

/**
 * 获取工单列表状态数量
 * @param limit - 每页显示数量
 * @param page - 当面页码
 */
export function getOrderStatusQty(
  limit: number,
  page: number,
): AxiosPromise<OrderAPIResponse.ListStatusQty> {
  return request({
    url: '/work/order/getOrderStatusQty',
    method: 'get',
    params: {
      limit,
      page,
    },
  })
}

/**
 * 根据工单ID获取工单详情
 * @param id - 工单id
 */
export function getOrderDetail(id: string): AxiosPromise<OrderAPIResponse.Detail> {
  return request({
    url: '/work/order/getOrderDetail/' + id,
    method: 'get',
  })
}

/**
 * 根据模块ID获取工单自定义字段
 * @param moduleId - 工单模块id
 */
export function getModuleField(
  moduleId: string,
): AxiosPromise<OrderAPIResponse.CustomFieldForCreate> {
  return request({
    url: `/work/module/field/getModuleField/${moduleId}`,
    method: 'get',
  })
}

/**
 * 获取工单列表搜索条件的工单自定义搜索字段
 */
export function getOrderListSelectField() {
  return request({
    url: '/work/order/getOrderListSelectField',
    method: 'get',
  })
}

/**
 * 批量分配客服
 * @param data - 工单ID
 * @param empId - 客服人员ID
 */
export function dispatchOrderEmp(data: Array<string>, empId: string) {
  return request({
    url: '/work/order/dispatchOrderEmp/' + empId,
    method: 'put',
    data,
  })
}

/**
 * 批量更新工单流程为完成
 * @param data - 请求参数
 * @param data.remark - 原因/备注
 * @param data.settlementStatus - 工单结算方式：1-待结算，2-已结算
 * @param data.workIds - 工单ID
 */
export function finishOrder(data: {
  remark: string
  settlementStatus: 1 | 2 | ''
  workIds: Array<string>
}) {
  return request({
    url: '/work/order/finishOrder',
    method: 'put',
    data,
  })
}

/**
 * 批量更新工单流程为取消
 * @param data - 请求参数
 * @param data.remark - 原因/备注
 * @param data.settlementStatus - 工单结算方式：1-待结算，2-已结算
 * @param data.workIds - 工单ID
 */
export function cancelOrder(data: {
  remark: string
  settlementStatus: 1 | 2 | ''
  workIds: Array<string>
}) {
  return request({
    url: '/work/order/cancelOrder',
    method: 'put',
    data,
  })
}

/**
 * 工单催单
 * @param data - 请求参数
 * @param data.content - 催单内容
 * @param data.remindEmpType - 提醒人员类型：1-工单客服，2-服务商负责人，3-工程师，注：可多选
 * @param data.workIds - 工单ID集合
 */
export function saveReminder(data: {
  content: string
  remindEmpType: Array<1 | 2 | 3 | ''>
  workIds: Array<string>
}) {
  return request({
    url: '/work/order/saveReminder',
    method: 'post',
    data,
  })
}

/**
 * 根据工单ID获取工单催单列表
 * @param data - 请求参数
 * @param data.limit - 每页显示数量
 * @param data.page - 当面页码
 * @param workId - 工单ID
 */
export function getReminderList(data: { limit: number; page: number }, workId: string) {
  return request({
    url: '/work/order/getReminderList/' + workId,
    method: 'post',
    data,
  })
}

/**
 * 根据工单ID获取工单产品
 * @param data - 请求参数
 * @param data.limit - 每页显示数量
 * @param data.page - 当面页码
 * @param workId - 工单ID
 */
export function getOrderGoodsDetail(
  workId: string,
  data: { limit: number; page: number },
): AxiosPromise<APIResponseList<OrderDetailAPIResponse.GoodListItem>> {
  return request({
    url: '/work/order/getOrderGoodsDetail/' + workId,
    method: 'post',
    data,
  })
}

/**
 * 根据工单ID获取工单操作记录列表
 * @param data - 请求参数
 * @param data.limit - 每页显示数量
 * @param data.page - 当面页码
 * @param workId - 工单ID
 */
export function getOrderLog(data: { limit: number; page: number }, workId: string) {
  return request({
    url: '/work/order/getOrderLog/' + workId,
    method: 'post',
    data,
  })
}

/**
 * 工单预约时间
 * @param data - 请求参数
 * @param data.date - 预约日期
 * @param data.remark - 原因/备注
 * @param data.reservationEndTime - 预约结束时间
 * @param data.reservationStartTime - 预约开始时间
 * @param data.workId - 工单ID
 */
export function reservationTime(data: {
  date: string
  remark: string
  reservationEndTime: string
  reservationStartTime: string
  workId: string
}) {
  return request({
    url: '/work/order/reservationTime',
    method: 'put',
    data,
  })
}

/**
 * 派单给网点
 * @param data - 请求参数
 * @param data.networkEmpId - 服务商人员ID
 * @param data.networkId - 服务商ID
 * @param data.remark - 派单备注
 * @param data.workIds - 工单ID
 */
export function orderDispatchNetwork(
  data: OrderAPIRequestParam.OrderDispatchNetwork,
): AxiosPromise<APIResponse> {
  return request({
    url: '/work/order/orderDispatchNetwork',
    method: 'put',
    data,
  })
}

/**
 * 根据工单ID获取工单留言
 * @param data - 请求参数
 * @param data.limit - 每页显示数量
 * @param data.page - 当面页码
 * @param workId - 工单ID
 */
export function getWorkLeaveMessageList(data: { limit: number; page: number }, workId: string) {
  return request({
    url: '/work/order/getWorkLeaveMessageList/' + workId,
    method: 'post',
    data,
  })
}

/**
 * 保存工单留言
 * @param data - 请求参数
 * @param data.annex - 附件
 * @param data.content - 留言内容
 * @param data.visitTypes - 可见类型：0-公开，1-服务商，2-工程师，3-工单客户，4-工单客服
 * @param data.workId - 工单ID
 */
export function saveWorkLeaveMessage(data: {
  annex: Array<string>
  content: string
  visitTypes: Array<0 | 1 | 2 | 3 | 4>
  workId: string
}) {
  return request({
    url: '/work/order/saveWorkLeaveMessage',
    method: 'post',
    data,
  })
}

/**
 * 改派服务商
 * @param data - 请求参数
 * @param data.changeToNetworkEmpId - 改派的服务商人员ID
 * @param data.changeToNetworkId - 改派的服务商ID
 * @param data.currentNetworkId - 当前服务商ID
 * @param data.remark - 备注
 * @param data.workId - 工单ID
 */
export function changeNetwork(data: {
  changeToNetworkEmpId: string
  changeToNetworkId: string
  currentNetworkId: string
  remark: string
  workId: string
}): AxiosPromise<APIResponse> {
  return request({
    url: '/work/order/changeNetwork',
    method: 'put',
    data,
  })
}

/**
 * 改派工单客服
 * @param data - 请求参数
 * @param data.empId - 改派的工单客服ID
 * @param data.remark - 备注
 * @param data.workId - 工单ID
 */
export function changeServiceEmp(data: { empId: string; remark: string; workId: string }) {
  return request({
    url: '/work/order/changeServiceEmp',
    method: 'put',
    data,
  })
}

// 根据工单ID获取网点信息
export function getServiceInfo(workId: string | string[]) {
  return request({
    url: '/work/order/getServiceInfo/' + workId,
    method: 'get',
  })
}

/**
 * 获取工单列表表头的工单自定义字段
 */
export function getOrderListTableTitleField(): AxiosPromise<OrderAPIResponse.OrderListTableHeaderCustomFieldList> {
  return request({
    url: '/work/order/getOrderListTableTitleField',
    method: 'get',
  })
}

/**
 * 根据工单ID获取服务项目列表
 * @param {Object} data - 请求参数
 * @param {Number} data.limit - 一页显示多少条
 * @param {Number} data.page - 页码
 * @param {String} workId - 工单id
 */
export function getOrderDetailFeeProjectList(
  data: { limit: number; page: number },
  workId: string,
): AxiosPromise<APIResponseList<OrderFeeAPIResponse.OrderDetailFeeListItem>> {
  return request({
    url: '/work/fee/getOrderDetailFeeProjectList/' + workId,
    method: 'post',
    data,
  })
}

// 获取工单服务费用项目列表
export function feeWork(data: {
  applyEmp: string
  createEndTime: string
  createStartTime: string
  feeNo: string
  limit: number
  page: number
  status: any
  workNo: string
}) {
  return request({
    url: '/work/fee/getList',
    method: 'post',
    data,
  })
}

/**
 * 根据服务项目ID获取项目信息列表
 * @param id - 费用id
 */
export function OrderFeeDetailProjectInfo(
  id: string,
): AxiosPromise<APIResponse<Array<OrderFeeAPIResponse.OrderDetailFeeDetailProject>>> {
  return request({
    url: '/work/fee/getOrderFeeDetailProjectInfo/' + id,
    method: 'get',
  })
}

/**
 * 审核工单服务费用项目
 * @param data - 请求参数
 */
export function checkOrderFee(
  data: OrderFeeAPIRequest.OrderDetailFeeForm,
): AxiosPromise<APIResponse> {
  return request({
    url: '/work/fee/checkOrderFee',
    method: 'post',
    data,
  })
}

/**
 * 保存或修改工单服务费用
 * @param data - 请求参数
 */
export function feeSaveOrder(
  data: OrderFeeAPIRequest.OrderDetailFeeForm,
): AxiosPromise<APIResponse> {
  return request({
    url: '/work/fee/save',
    method: 'post',
    data,
  })
}

/**
 * 工单费用项目下拉列表查询
 * @param {Object} data - 请求参数
 * @param {String} data.name - 搜索关键词
 * @param {String} data.limit - 每页显示数量
 * @param {String} data.page - 当面页码
 */
export function workFeeProjectPageSelect(
  data: OrderFeeAPIRequest.GetFeeOptionsParam,
): AxiosPromise<APIResponseList<OrderFeeAPIResponse.OrderFeeOption>> {
  return request({
    url: '/order/select/workFeeProjectPageSelect',
    method: 'post',
    data,
  })
}

/**
 * 根据服务项目ID获取服务项目详情
 * @param {string} id - 费用id
 */
export function getOrderFeeDetail(
  id: string,
): AxiosPromise<APIResponse<OrderFeeAPIResponse.OrderDetailFeeDetail>> {
  return request({
    url: '/work/fee/getOrderFeeDetail/' + id,
    method: 'get',
  })
}

// 根据服务项目ID获取服费用项目日志列表
export function getOrderFeeLogList(data, id) {
  return request({
    url: '/work/fee/getOrderFeeLogList/' + id,
    method: 'post',
    data,
  })
}

/**
 * 分页获取工单物料下拉数据列表
 * @param {object} data - 请求参数
 * @param {number} data.limit - 一页显示多少条
 * @param {number} data.page - 当前页码
 * @param {string} data.name - 搜索关键字
 * @param {string} workId - 工单id
 */
export function getOrderSparePageSelect(
  data: { limit: number; page: number; name: string },
  workId: string,
): AxiosPromise<APIResponseList<OrderSparePartAPIResponse.SparePartOption>> {
  return request({
    url: '/order/select/getOrderSparePageSelect/' + workId,
    method: 'post',
    data,
  })
}

/**
 * 分页获取工单物料规格下拉数据列表
 * @param data - 请求参数
 * @param materialId - 配件id
 */
export function getOrderSpareSpecSelect(
  data: { limit: number; page: number; name: string },
  materialId: string,
): AxiosPromise<OrderAPIResponse.MaterialSpecOptionList> {
  return request({
    url: '/order/select/getOrderSpareSpecSelect/' + materialId,
    method: 'post',

    data,
  })
}

// 根据工单ID获取工单信息
export function getOrderParamField(workId) {
  return request({
    url: '/work/order/getOrderParamField/' + workId,
    method: 'get',
  })
}

// 获取工单列表表头字段
export function getOrderListTableField(type) {
  return request({
    url: '/workTableField/getOrderListTableField/' + type,
    method: 'get',
  })
}
// 获取工单表头字段设置项
export function getOrderTableField(type) {
  return request({
    url: '/workTableField/getOrderTableField/' + type,
    method: 'get',
  })
}
// 保存或更新工单表头字段
export function workTableFieldSave(data, type) {
  return request({
    url: '/workTableField/save/' + type,
    method: 'post',

    data,
  })
}
// 获取工单列表排序字段设置
export function getOrderTableOrderByField(type) {
  return request({
    url: '/orderBy/field/getOrderTableOrderByField/' + type,
    method: 'get',
  })
}
// 新增或修改工单列表排序字段
export function orderBySave(data, type) {
  return request({
    url: '/orderBy/field/save/' + type,
    method: 'post',

    data,
  })
}

//获取工单表头初始化字段
export function getOrderTableInitField() {
  return request({
    url: '/workTableField/getOrderTableInitField',
    method: 'get',
  })
}
//获取工单列表排序初始化字字段
export function getOrderTableInitOrderByField() {
  return request({
    url: '/orderBy/field/getOrderTableInitOrderByField',
    method: 'get',
  })
}
//工单模块带费用下拉列表查询
export function workModulePricePageSelect(data) {
  return request({
    url: '/order/select/workModulePricePageSelect',
    method: 'post',

    data,
  })
}

// 获取工单所有导出字段
export function getOrderExportField() {
  return request({
    url: '/work/export/field/getOrderExportField',
    method: 'get',
  })
}

// 获取工单自定义字段
export function getOrderCustomField() {
  return request({
    url: '/work/export/field/getOrderCustomField',
    method: 'get',
  })
}

/**
 * 获取工单结单导出字段
 */
export function getOrderEndExportFieldListApi() {
  return request({
    url: '/work/export/field/getOrderSettlementField',
    method: 'get',
  })
}

// 获取工单系统初始导出字段
export function getOrderSysExportFields() {
  return request({
    url: '/work/export/field/getOrderSysExportFields',
    method: 'get',
  })
}

// 保存导出字段
export function saveExportField(data) {
  return request({
    url: '/work/export/field/save',
    method: 'post',

    data,
  })
}

// 保存并导出字段
export function saveAndExportField(data) {
  return request({
    url: '/work/export/field/saveAndExportField',
    method: 'post',

    data,
    responseType: 'blob',
  })
}

/**
 * 获取工单详情的合计总费用
 * @param {string} id - 工单id
 */
export function getOrderTotalFee(id: string) {
  return request({
    url: `/work/order/getOrderTotalFee/${id}`,
    method: 'get',
  })
}

/**
 * 发送结单核销码
 * @param {string} id 工单id
 * @returns {Promise<any>}
 */
export function sendOrderStatementWriteOffCode(id: string) {
  return request({
    url: `/work/order/sendOrderStatementWriteOffCode/${id}`,
    method: 'get',
  })
}

/**
 * 获取待审核的工单事件
 * @param {string} id 工单ID
 */
export function getWaitCheckOrderEvent(
  id: string,
): AxiosPromise<OrderAPIResponse.WaitHanldeEventList> {
  return request({
    url: `/work/order/getWaitCheckOrderEvent/${id}`,
    method: 'get',
  })
}

/**
 * 审核取消工单
 * @param {string} orderId - 工单id
 * @param {object} data - 请求参数
 * @param {1 | 2} data.checkType - 取消工单审核类型：1-审核通过，2-驳回
 * @param {string} data.id - 取消工单ID
 * @param {string} data.remark - 审核备注
 */
export function checkCancelOrder(orderId: string, data: OrderAPIRequestParam.CheckCancelOrder) {
  return request({
    url: `/work/order/checkCancelOrder/${orderId}`,
    method: 'post',

    data,
  })
}

/**
 * 根据工单ID获取待审核取消工单
 * @param {string} id - 工单id
 */
export function getWaitCheckCancelOrder(id: string) {
  return request({
    url: `/work/order/getWaitCheckCancelOrder/${id}`,
    method: 'get',
  })
}

/**
 * 审核结单
 * @param {string} id - 工单id
 * @param {object} data - 请求参数
 * @param {1 | 2} data.checkType - 结单审核类型：1-审核通过，2-驳回
 * @param {string} data.id - 工单结单ID
 * @param {number} data.price - 结单总费用
 * @param {string} data.remark - 审核结单备注
 * @param {number} data.surePrice - 确认结单费用
 */
export function checkStatementOrder(id: string, data: OrderAPIRequestParam.CheckStatementOrder) {
  return request({
    url: `/work/order/checkStatementOrder/${id}`,
    method: 'post',

    data,
  })
}

/**
 * 根据工单ID获取工单待结单审核
 * @param {string} id - 工单id
 */
export function getWaitCheckStatementOrder(id: string) {
  return request({
    url: `/work/order/getWaitCheckStatementOrder/${id}`,
    method: 'get',
  })
}

// 获取工单最新进展
export function getOrderLastLog(id: string) {
  return request({
    url: `/work/order/getOrderLastLog/${id}`,
    method: 'get',

    cancelToken: new cancelToken((c) => {
      // 接收一个 cancel 函数作为参数
      cancel = c
    }),
  })
}

// 取消上一次请求获取工单最新进展
export function axiosCancel() {
  cancel()
}

/**
 * 保存工单备注
 * @param {object} data - 请求参数
 * @param {Array<any>} data.annexs - 工单备注附件
 * @param {string} data.remark - 工单备注
 * @param {0 | 1 | 2 | 3 | 4} data.visitTypes - 可见类型：0-公开，1-网点，2-工程师，3-工单公司，4-工单客服
 * @param {Array<string>} data.workIds - 工单ID参数
 */
export function saveRemark(data: OrderAPIRequestParam.SaveOrderRemark) {
  return request({
    url: '/ork/remark/save',
    method: 'post',

    data,
  })
}

/**
 * 工单超时提醒
 * @param {Array<string>} data.remindEmpIds 指定人员ID
 * @param {Array<number>} data.remindEmpType 提醒人员类型：1-工单客服，2-网点负责人，3-工程师，4-指定人员
 * @param {Array<string>} data.workIds 工单ID
 */
export function workTimeoutRemind(data) {
  return request({
    url: '/work/order/workTimeoutRemind',
    method: 'post',

    data,
  })
}

/**
 * 获取预约时间范围
 * @param {string} workId - 工单id
 */
export function getReservationRange(workId: string) {
  return request({
    url: `/work/order/getReservationRange/${workId}`,
    method: 'get',
  })
}

/**
 * 根据工单ID获取待审核改派网点的工单
 * @param {string} id - 工单id
 */
export function getWaitCheckWorkReassign(id: string) {
  return request({
    url: `/work/order/getWaitCheckWorkReassign/${id}`,
    method: 'get',
  })
}

/**
 * 审核改派网点的工单
 * @param {Object} data - 请求参数
 * @param {string} data.changeToNetworkId - 新网点ID
 * @param {1 | 2} data.checkTypep - 审核类型：1-审核通过，2-驳回
 * @param {string} data.id - 改派工单ID
 * @param {string} data.networkEmpId - 新网点工程师ID
 * @param {string} data.remark - 备注
 * @param {string} workId - 工单id
 */
export function checkWorkReassign(data: OrderAPIRequestParam.CheckWorkReassign, workId: string) {
  return request({
    url: `/work/order/checkWorkReassign/${workId}`,
    method: 'post',
    data,
  })
}
// 根据工单ID获取结单字段
export function getOrderSettlementField(workId: any) {
  return request({
    url: `/work/order/getOrderSettlementField/${workId}`,
    method: 'get',
  })
}
/**获取历史工单列表 */
export function getHistoryOrderList(data) {
  return request({
    url: `/history/order/getHistoryOrderList`,
    method: 'post',
    data,
  })
}
/**获取历史工单详情 */
export function getHistoryDetail(id) {
  return request({
    url: `/history/order/getDetail/${id}`,
    method: 'get',
  })
}
/**获取历史工单产品*/
export function getHistoryOrderGoods(id, data) {
  return request({
    url: `/history/order/getHistoryOrderGoods/${id}`,
    method: 'post',
    data,
  })
}
/**批量删除历史工单*/
export function deleteHistoryOrder(data) {
  return request({
    url: `/history/order/deleteHistoryOrder`,
    method: 'DELETE',
    data,
  })
}

/**
 * 保存或修改服务费用标准
 * @param {OrderFeeStandardDetail} data - 收费标准详情
 */
export function serviceStandardSave(data: OrderFeeStandardDetail): AxiosPromise<APIResponse> {
  return request({
    url: '/work/service/fee/standard/save',
    method: 'post',
    data,
  })
}

/**获取服务费用列表*/
export function serviceStandardgetList(data): AxiosPromise<OrderAPIResponse.FeeStandards> {
  return request({
    url: `/work/service/fee/standard/getList`,
    method: 'post',
    data,
  })
}

/**
 * 获取服务费用标准详情
 * @param {String} id - 收费标准id
 */
export function standardgetDetail(id: string): AxiosPromise<OrderAPIResponse.FeeStandardDetail> {
  return request({
    url: `/work/service/fee/standard/getDetail/${id}`,
    method: 'get',
  })
}

/**
 * 批量更新是否移动端显示
 * @param {Array<string>} data - 收费标准id集合
 * @param {Boolean} status - 是否移动显示：false-隐藏，true-显示
 */
export function updateMobileShow(data: Array<string>, status: boolean): AxiosPromise<APIResponse> {
  return request({
    url: '/work/service/fee/standard/updateMobileShow',
    method: 'post',
    data,
    params: { mobileShow: status },
  })
}

/**
 * 收费标准批量删除
 * @param {Array<string>} data - 收费标准id集合
 */
export function feeStandardsDelete(data: Array<string>): AxiosPromise<APIResponse> {
  return request({
    url: '/work/service/fee/standard/delete',
    method: 'post',
    data,
  })
}

/**
 * 收费标准批量禁用或启用
 * @param {Array<string>} data - 收费标准id集合
 * @param {Boolean} status - false（启用），true（禁用）
 */
export function feeStandardsDisable(
  data: Array<string>,
  status: boolean,
): AxiosPromise<APIResponse> {
  return request({
    url: '/work/service/fee/standard/disable',
    method: 'post',
    data,
    params: { status },
  })
}

/**
 * 更改工单产品条码
 * @param {OrderAPIRequest.UpdateGoodSncode} data - 请求参数
 * @param {Array<string>} data.snCodes - SN码
 * @param {string} data.workGoodsId - 工单商品ID
 */
export function updateWorkGoodsBindSnCode(
  data: OrderAPIRequest.UpdateGoodSncode,
  workId: string,
): AxiosPromise<APIResponse> {
  return request({
    url: `/work/order/updateWorkGoodsBindSnCode/${workId}`,
    method: 'POST',
    data,
  })
}

/**
 * 新增或修改结算方案
 * @param {Object} data - 请求参数
 */
export const goodSettleAddOrUpdate = (
  data: OrderAPIRequest.GoodSettleForm,
): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/goods/settlement/programme/save',
    method: 'post',

    data,
  })
}

/**
 * 获取结算方案列表
 * @param {Object} data - 请求参数
 * @param {String} data.goodsKeyword - 产品搜索关键词：产品名称/产品编号/产品型号
 * @param {String} data.goodsOneTypeId - 一级产品分类ID
 * @param {String} data.goodsThreeTypeId - 三级产品分类ID
 * @param {String} data.goodsTwoTypeId - 二级产品分类ID
 * @param {Number} data.limit - 每页显示数量
 * @param {String} data.name - 方案名称
 * @param {Number} data.page - 当面页码
 */
export const getGoodSettles = (
  data: OrderAPIRequest.GoodSettles,
): AxiosPromise<OrderAPIResponse.OrderGoodSettleList> => {
  return request({
    url: '/work/goods/settlement/programme/getList',
    method: 'post',

    data,
  })
}

/**
 * 批量启用或禁用结算方案
 * @param {Array<string>} ids - 结算方案ID集合
 * @param {Boolean} status - 结算方案状态：false-启用，true-禁用
 */
export const goodSettlesUpdateStatus = (
  ids: Array<string>,
  status: boolean,
): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/goods/settlement/programme/disabled',
    method: 'post',

    data: ids,
    params: {
      status,
    },
  })
}

/**
 * 批量删除结算方案
 * @param {Array<string>} ids - 结算方案ID集合
 */
export const goodSettlesDel = (ids: Array<string>): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/goods/settlement/programme/delete',
    method: 'post',

    data: ids,
  })
}

/**
 * 根据id获取产品结算方案
 * @param {String} id - 产品结算方案id
 */
export const getGoodSettleDetailById = (
  id: string,
): AxiosPromise<OrderAPIResponse.GoodSettleDetail> => {
  return request({
    url: `/work/goods/settlement/programme/getDetail/${id}`,
    method: 'get',
  })
}
/**
 * 查询是否存在重单
 * @param {repeatOrder} data
 */
export function getRepeatOrder(data) {
  return request({
    url: `/work/order/getRepeatOrder`,
    method: 'post',
    data,
  })
}
/**
 * 获取查询重单设置
 */
export function getRepeatOrderSet() {
  return request({
    url: `/work/order/getRepeatOrderSet`,
    method: 'get',
  })
}

/**
 * 获取修改工单公司前的信息
 * @param {string} workId - 工单id
 */
export function getBeforeUpdateWorkUserInfo(
  workId: string,
): AxiosPromise<OrderAPIResponse.UserInfoBeforeUpdate> {
  return request({
    url: `/work/order/getBeforeUpdateWorkUserInfo/${workId}`,
    method: 'get',
  })
}

/**
 * 保存更改的工单公司信息
 * @param {OrderAPIRequest.UpdateOrderUserInfo} data - 请求参数
 * @param {string} data.address - 客户详细地址
 * @param {string} data.area - 地址-县/区
 * @param {string} data.city - 地址-市
 * @param {0|1} data.helpOtherCreateOrder - 是否代他人建单：0-否，1-是
 * @param {string} data.name - 公司名称
 * @param {string} data.otherPhone - 其他电话
 * @param {string} data.phone - 公司联系方式
 * @param {string} data.province - 地址-省
 * @param {string} data.repairCompany - 报修公司名称
 * @param {string} data.repairCompanyId - 报修公司ID
 * @param {string} data.repairCompanyPhone - 报修公司联系方式
 * @param {string} data.sendForRepairPhone - 送修人联系手机号
 * @param {string} data.sendForRepairUsername - 送修人名称
 * @param {string} data.town - 地址-镇
 * @param {string} data.userId - 公司ID
 */
export function saveUpdateWorkUser(
  data: OrderAPIRequest.UpdateOrderUserInfo,
): AxiosPromise<APIResponse> {
  return request({
    url: '/work/order/saveUpdateWorkUser',
    method: 'post',
    data,
  })
}

/**
 * 获取修改前的工单信息
 * @param {String} orderId - 工单id
 */
export function getBeforeUpdateWorkInfo(
  orderId: string,
): AxiosPromise<OrderAPIResponse.InfoBeforeEdit> {
  return request({
    url: `/work/order/getBeforeUpdateWorkInfo/${orderId}`,
    method: 'get',
  })
}

/**
 * 保存修改的工单信息
 * @param {OrderAPIRequest.OrderUpdateInfoForm} data - 更新后的工单信息
 * @param {String} workId - 工单id
 */
export function saveWorkInfo(
  data: OrderAPIRequest.OrderUpdateInfoForm,
  workId: string,
): AxiosPromise<APIResponse> {
  return request({
    url: `/work/order/saveWorkInfo/${workId}`,
    method: 'post',
    data,
  })
}

/**
 * 根据工单ID获取待审核的工单费用
 * @param id - 工单id
 */
export const getWaitCheckFeeByOrderId = (
  id: string,
): AxiosPromise<OrderAPIResponse.OrderFeeListByOrderId> => {
  return request({
    url: `/work/fee/getWaitCheckOrderFee/${id}`,
    method: 'get',
  })
}

/**
 * 工单费用批量审核
 * @param data - 请求参数
 */
export const orderFeeMultipleCheck = (
  data: OrderAPIRequest.FeeMultipleCheck,
): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/fee/checkOrderFeeBatch',
    method: 'post',
    data,
  })
}

/**
 * 获取工单来源列表
 * @param {Object} data - 请求参数
 * @param {Number} data.limit - 每页显示数量
 * @param {Number} data.name - 搜索关键词
 * @param {String} data.page - 当面页码
 */
export const getSourceList = (data: {
  limit: number
  page: number
  name: string
}): AxiosPromise<OrderAPIResponse.SourceList> => {
  return request({
    url: '/work/source/getList',
    method: 'post',
    data,
  })
}

/**
 * 批量禁用或启用来源状态
 * @param ids - 工单来源ID集合
 * @param status - 来源状态：false-启用，true-禁用
 */
export const updateSourceStateByIds = (
  ids: Array<string>,
  status: boolean,
): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/source/disable',
    method: 'post',
    data: ids,
    params: {
      status,
    },
  })
}

/**
 * 批量删除工单来源
 * @param ids - 工单来源ID集合
 */
export const delSourceByIds = (ids: Array<string>): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/source/delete',
    method: 'delete',
    data: ids,
  })
}

/**
 * 修改默认来源
 * @param id - 工单来源ID
 */
export const updateDefaultSourceById = (id: string): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/source/updateDefaultSource/${id}`,
    method: 'post',
  })
}

/**
 * 新增或修改工单来源
 * @param {OrderAPIRequest.SourceForm} data - 请求参数
 * @param {Boolean} data.defaultSelect - 是否默认选中：false-否，true-是
 * @param {String} data.id - 来源ID，新增不必传，修改必传
 * @param {String} data.name - 来源名称
 * @param {Boolean} data.status - 来源状态：false-启用，true-禁用
 */
export const sourceSave = (data: OrderAPIRequest.SourceForm): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/source/save',
    method: 'post',
    data,
  })
}

/**
 * 获取来源详情
 * @param id - 来源id
 */
export const getSourceDetail = (id: string): AxiosPromise<OrderAPIResponse.SourceDetail> => {
  return request({
    url: `/work/source/getDetail/${id}`,
    method: 'get',
  })
}

/**
 * 获取来源下拉选项
 * @param {Object} data - 请求参数
 * @param {String} data.name - 搜索关键词
 * @param {Number} data.limit - 每页显示数量
 * @param {Number} data.page - 当面页码
 */
export const getSourceOptionList = (data: {
  limit: number
  page: number
  name: string
}): AxiosPromise<OrderAPIResponse.SourceOptionList> => {
  return request({
    url: '/order/select/getWorkSource',
    method: 'post',
    data,
  })
}

/**
 * 获开票信息
 * @param orderId - 工单id
 */
export const getBillInfo = (orderId: string): AxiosPromise<OrderAPIResponse.BillInfo> => {
  return request({
    url: `/work/order/getWorkTicketDetail/${orderId}`,
    method: 'get',
  })
}

/**
 * 新增或修改工单质保类别
 * @param data - 请求参数
 */
export const warrantyCategoryFormSave = (
  data: OrderAPIRequest.WarrantyCategoryForm,
): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/warranty/category/save',
    method: 'post',
    data,
  })
}

/**
 * 工单质保类别列表
 * @param data - 请求参数
 * @param data.name - 搜索关键词
 * @param data.limit - 每页显示数量
 * @param data.page - 当面页码
 */
export const getWarranryCategoryList = (data: {
  limit: number
  page: number
  name: string
}): AxiosPromise<OrderAPIResponse.WarrantyCategoryList> => {
  return request({
    url: '/work/warranty/category/getList',
    method: 'post',
    data,
  })
}

/**
 * 根据工单质保类别id获取详情
 * @param {String} id - 质保类别id
 */
export const getOrderWarrantyCategoryDetail = (
  id: string,
): AxiosPromise<OrderAPIResponse.WarrantyCategoryDetail> => {
  return request({
    url: `/work/warranty/category/getDetail/${id}`,
    method: 'get',
  })
}

/**
 * 根据质保类别id删除质保类别
 * @param idList - 质保类别id集合
 */
export const delWarrantyCategoryByIds = (idList: Array<string>): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/warranty/category/delete',
    method: 'delete',
    data: idList,
  })
}

/**
 * 根据工单质保类别ID批量启用或禁用工单
 * @param idList 质保类别ID集合
 * @param status 质保类别状态：false-启用，true-禁用
 */
export const updateWarrantyCategoryStatusByIds = (
  idList: Array<string>,
  status: boolean,
): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/warranty/category/disable',
    method: 'post',
    data: idList,
    params: {
      status,
    },
  })
}

/**
 * 获取工单质保类别
 * @param data - 请求参数
 * @param data.name - 搜索关键词
 * @param data.page - 当面页码
 * @param data.limit - 每页显示数量
 */
export const getOrderWarrantyCategoryOptionList = (data: {
  name: string
  limit: number
  page: number
}): AxiosPromise<OrderAPIResponse.WarrantyCategoryOptionsList> => {
  return request({
    url: '/order/select/getWorkWarrantyCategory',
    method: 'post',
    data,
  })
}

/**
 * 获取打印信息
 * @param orderId - 工单id
 */
export const getOrderFeeDetailPrint = (
  orderId: string,
): AxiosPromise<OrderAPIResponse.DetailPrint> => {
  return request({
    url: `/work/order/getOrderFeeDetailPrint/${orderId}`,
    method: 'get',
  })
}

/**
 * 审核报价
 * @param {object} param - 请求参数
 * @param {boolean} param.checkResult - 审核结果：false-驳回，true-通过
 * @param {string} param.remark - 备注
 * @param {string} orderId - 工单id
 */
export const checkQuote = (
  param: { checkResult: boolean; remark: string },
  orderId: string,
): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/spare/fee/checkSpareWithFee/${orderId}`,
    method: 'post',
    data: param,
  })
}

/**
 * 审核条码
 * @param {object} data - 请求参数
 * @param {boolean} data.checkResult - 审核结果
 * @param {string} data.remark - 备注
 * @param {string} orderId - 工单id
 */
export const checkCode = (
  data: { checkResult: boolean; remark: string },
  orderId: string,
): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/order/checkBindingSnCode/${orderId}`,
    method: 'post',
    data,
  })
}

/**
 * 更改物料的条码
 * @param {Array<{ snCode: string; workSapreMaterialId: string; workSpareId: string }>} data - 请求参数
 * @param {string} orderId - 工单id
 */
export const updateMaterialSnCode = (
  data: Array<{ snCode: string; workSapreMaterialId: string; workSpareId: string }>,
  orderId: string,
): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/spare/fee/updateWorkSpareMaterial/${orderId}`,
    method: 'post',
    data,
  })
}

/**
 * 申请结单（网点角色使用）
 * @param {OrderAPIRequest.EndOrderApply} data - 请求参数
 * @param {string} orderId - 工单id
 */
export const engineerEndOrderApply = (
  data: OrderAPIRequest.EndOrderApply,
  orderId: string,
): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/order/networkApplyFinishOrder/${orderId}`,
    method: 'post',
    data,
  })
}

/**
 * 确定领料（网点角色使用）
 * @param {string} orderId - 工单id
 */
export const engineerTakeMaterialConfirm = (orderId: string): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/order/saveToPickingOrderMaterial/${orderId}`,
    method: 'post',
  })
}

/**
 * 更新百事工单状态
 * @param {string} orderId - 工单id
 */
export const updateBaishiOrderStatus = (
  orderId: string,
  data: OrderAPIRequest.UpdateBaishiOrderStatus,
): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/order/updateBaiShiOrderStatus/${orderId}`,
    method: 'post',
    data,
  })
}

/**
 * 更改工单结算价
 * @param {object} data - 请求参数
 * @param {string} data.workId - 工单id
 * @param {number} data.networkModulePrice - 服务商模块费用
 */
export function updateSettlementPrice(data: {
  workId: string
  networkModulePrice: number
}): AxiosPromise<APIResponse> {
  return request({
    url: '/work/order/updateSettlementPrice',
    method: 'post',

    data,
  })
}

// 获取当前账号的商用-家用类型
export function getOrganType() {
  return request({
    url: '/order/select/getOrganType',
    method: 'get',
  })
}

/**
 * 获取工单结单状态
 * @param {string} id - 工单id
 */
export const getOrderEndStatus = (id: string): AxiosPromise<NewAPIResponse<boolean>> => {
  return request({
    url: `/work/finalizing/bill/status/${id}`,
    method: 'get',
  })
}

/**
 * 获取结单列表
 * @param {string} id - 工单id
 */
export const getEndOrderFieldList = (
  id: string,
): AxiosPromise<OrderAPIResponse.OrderEndFieldList> => {
  return request({
    url: `/work/finalizing/bill/${id}`,
    method: 'get',
  })
}

/**
 * 保存、修改、审核结单信息
 * @param {string} id - 工单id
 * @param {0|1|2|3} type - 保存类型，0->申请 1->审核通过 2->审核驳回 3->保存并审核
 * @param {string} moduleId - 工单模块id
 * @param {Array<OrderEndFieldListItem['objects']>} data - 请求参数
 */
export const saveEndOrderResult = (
  id: string,
  type: 0 | 1 | 2 | 3,
  moduleId: string,
  data: OrderEndFieldListItem['objects'],
): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/finalizing/bill/${moduleId}/${id}/${type}`,
    method: 'post',
    data,
  })
}

/**
 * 在结单界面获取工单模板：根据工单类型和工单ID获取工单模板
 * @param {string} moudleId - 工单模块id
 * @param {string} orderId - 工单id
 */
export const getTemplateByModuleAndOrderId = (
  moudleId: string,
  orderId: string,
): AxiosPromise<NewAPIResponse<OrderTemplateForUpdateEndTemplate>> => {
  return request({
    url: `/work/finalizing/bill/${moudleId}/${orderId}`,
    method: 'get',
  })
}

/**
 * 重新推送工单到电匠院
 * @param {string} orderId - 工单id
 */
export const pushOrderToDianJiangYuan = (orderId: string): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/order/pushWorkOrderThirdDjy/${orderId}`,
    method: 'get',
  })
}

/**
 * 根据编码查询，用于工单详情更换条码
 * @param {string} snCode - 条码
 */
export const queryCodeForUpdateCode = (
  snCode: string,
): AxiosPromise<OrderAPIResponse.SnCodeInfoForUpdateCode> => {
  return request({
    url: `/code/${snCode}`,
    method: 'get',
  })
}

/**
 * 获取编辑之前的工单费用信息（获取全部的）
 * @param {string} orderId - 工单id
 */
export const getOrderAllFeeInfoBeforeEdit = (
  orderId: string,
): AxiosPromise<APIResponseRows<Array<OrderFeeAPIResponse.FeeInfoBeforeEdit>>> => {
  return request({
    url: `/work/fee/getOrderFeeDetailV2/${orderId}`,
    method: 'get',
  })
}

/**
 * 更新工单详情的费用信息
 * @param {OrderFeeAPIRequest.UpdateOrderDetailFee} data - 更新表单
 */
export const updateOrderDetailFee = (
  data: OrderFeeAPIRequest.UpdateOrderDetailFee,
): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/fee/update',
    method: 'post',
    data,
  })
}

/**
 * 获取修改工单/新建工单的故障类型(反馈故障)下拉选项
 * @param {string} key - 搜索关键字
 */
export const getOrderSaveFaultTypeOptions = (
  key: string,
): AxiosPromise<APIResponse<Array<OrderSaveAPIResponse.FaultTypeOption>>> => {
  return request({
    url: '/knowledge/fault/selFailt',
    method: 'get',
    params: {
      key,
    },
  })
}

/**
 * 批量结单接口
 * @param {Array<string>} ids - 工单id集合
 * @param {number} type - 1->审核通过 2->审核驳回
 */
export const finishOrderMultipleCheck = (
  ids: Array<string>,
  type: 1 | 2,
): AxiosPromise<APIResponse> => {
  return request({
    url: `/work/finalizing/bill/batch/finalizingBill/${type}`,
    method: 'post',
    data: ids,
  })
}

/**
 * 分派/改派工程师
 * @param {OrderDetailAPiRequest.AssignEngineerForm} data - 请求参数
 * @param {string} data.networkEmpId - 服务商人员id
 * @param {string} data.networkId - 服务商id
 * @param {string} data.remark - 派单备注
 * @param {Array<string>} data.workIds - 工单id集合
 */
export const assignEngineer = (
  data: OrderDetailAPiRequest.AssignEngineerForm,
): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/order/orderDispatchEngineer',
    method: 'put',
    data,
  })
}

/**
 * 获取客户替换列表
 * @param keyword - 查询关键字
 */
export const getReplaceCustomerList = (
  keyword: string,
): AxiosPromise<APIResponse<Array<OrderDetailAPIResponse.ReplaceCustomer>>> => {
  return request({
    url: '/user/contact/selectName',
    method: 'post',
    data: {
      name: keyword,
    },
  })
}

/**
 * 获取工单设置的完工时效开始节点下拉选项
 * @param param - 请求参数
 * @param {number} param.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param {string} param.departmentId - 部门ID
 * @param {string} param.id - 搜索ID
 * @param {number} param.limit - 每页显示数量
 * @param {string} param.name - 搜索关键词
 * @param {number} param.page - 当面页码
 */
export const getOrderCompletionTimeLimitStartNodeOptions = (
  data: OrderSetAPIRequest.GetCompletionTimeLimitStartNodeOptionsParam,
): AxiosPromise<APIResponseList<OrderSetAPIResponse.CompletionTimeLimitStartNodeOption>> => {
  return request({
    url: '/order/select/getAgingBeginNode',
    method: 'post',
    data,
  })
}

/**
 * 获取工单设置的完工时效结束节点下拉选项
 * @param param - 请求参数
 * @param {number} param.ascriptionType - 模块类型归属：1=商用，2-家用
 * @param {string} param.departmentId - 部门ID
 * @param {string} param.id - 搜索ID
 * @param {number} param.limit - 每页显示数量
 * @param {string} param.name - 搜索关键词
 * @param {number} param.page - 当面页码
 */
export const getOrderCompletionTimeLimitEndNodeOptions = (
  data: OrderSetAPIRequest.GetCompletionTimeLimitEndNodeOptionsParam,
  startNodeId: 1 | 2 | 3,
): AxiosPromise<APIResponseList<OrderSetAPIResponse.CompletionTimeLimitEndNodeOption>> => {
  return request({
    url: `/order/select/getAgingEndNode/${startNodeId}`,
    method: 'post',
    data,
  })
}

/**
 * 网点确认接单
 * @param {object} data - 请求参数
 * @param {string} data.id - 工单id
 * @param {string} data.networkId - 网点id
 */
export const networkConfirmAcceptOrderApi = (data: {
  id: string
  networkId: string
}): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/order/orderNetwork/confirm',
    method: 'post',
    data,
  })
}

/**
 * 工程师确认接单
 * @param {object} data - 请求参数
 * @param {string} data.id - 工单id
 * @param {string} data.networkId - 网点id
 * @param {string} data.engineerId - 工程师id
 */
export const engineerConfirmAcceptOrderApi = (data: {
  id: string
  networkId: string
  engineerId: string
}): AxiosPromise<APIResponse> => {
  return request({
    url: '/work/order/orderNetwork/engineer/confirm',
    method: 'post',
    data,
  })
}
